package com.gxa.utils;


import java.io.InputStream;
import java.sql.*;
import java.util.Properties;
import java.util.ResourceBundle;

public class DBConnection {
    private static ResourceBundle bundle = ResourceBundle.getBundle("db"); // ResourceBundle.getBundle()千万不要加.properties后缀
    private static String driver = bundle.getString("jdbc.driver");
    private static String url = bundle.getString("jdbc.url");
    private static String user = bundle.getString("jdbc.username");
    private static String password = bundle.getString("jdbc.password");

    // 不让创建对象，因为工具类中的方法都是静态的。不需要创建对象
    // 为了防止创建对象，故将构造方法私有化。
    private DBConnection() {
    }

/*    static {
        InputStream inputStream = DBConnection.class.getClassLoader().getResourceAsStream("db.properties");
        Properties properties = new Properties();
        try {
            properties.load(inputStream);
            driver = properties.getProperty("jdbc.driver");
            url = properties.getProperty("jdbc.url");
            username = properties.getProperty("jdbc.username");
            password = properties.getProperty("jdbc.password");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }*/

    // DBConnection类加载时注册驱动
    static {
        try {
            Class.forName(driver);
        } catch (ClassNotFoundException e) {
            e.printStackTrace(); // 打印异常堆栈信息
        }
    }

    // 这个对象实际在服务器中只有1个
    private static ThreadLocal<Connection> local = new ThreadLocal<>();

/*    //获取连接
    public static Connection getConnection(){
        Connection connection;
        try {
            Class.forName(driver);
            connection = DriverManager.getConnection(url, user, password);
            return connection;
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }*/

    /**
     * 这里没有使用数据库连接池，直接创建的连接对象。
     * 每一次调用这个方法都是一个新的连接对象。
     *
     * @return 连接对象
     * @throws SQLException
     */
    public static Connection getConnection() throws SQLException {
        Connection conn = local.get();
        if (conn == null) {
            conn = DriverManager.getConnection(url, user, password);
            local.set(conn);
        }
        return conn;
    }

/*    //关闭连接
    public static void close(PreparedStatement ps,Connection connection){
        if(ps != null){
            try {
                ps.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if(connection != null){
            try {
                connection.close();
                local.remove();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }


    //关闭连接
    public static void close(ResultSet rs,PreparedStatement ps, Connection connection){
        if( rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
       close(ps,connection);
    }*/

    /**
     * 关闭资源
     *
     * @param conn      连接对象
     * @param statement 数据库操作对象
     * @param rs        结果集
     */
    public static void close(ResultSet rs, Statement statement, Connection conn) {
        if (rs != null) { // 关闭查询结果集
            try {
                rs.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }

        if (statement != null) { // 关闭数据库操作对象
            try {
                statement.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }

        if (conn != null) { // 关闭连接
            try {
                conn.close();
                // 思考一下：为什么conn关闭之后，这里要从大Map移除呢？
                // 根本原因是：Tomcat是支持线程池的。也就是说一个人用过了t1线程，t1线程还有可能被其他用户使用。
                local.remove();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
